﻿
#include <iostream>
#include <opencv2/opencv.hpp>  // 包含OpenCV库

using namespace cv;

int main()
{
    // 创建一个黑色背景的图像，大小为400*400
    Mat image(400, 400, CV_8UC3, Scalar(0, 0, 0));

    //设置箭头的初始位置和方向
    Point2f arrow_center(200, 200);  //箭头中心点
    double arrow_angle = 0.0;        //箭头角度（弧度）

    // 循环处理每帧图像
    while (true) {
        // 旋转箭头
        arrow_angle += 0.1;
        if (arrow_angle >= 2 * CV_PI) {
            arrow_angle -= 2 * CV_PI;
        }

        // 计算箭头的头和尾位置
        Point2f arrow_head(arrow_center.x + 50 * cos(arrow_angle),
            arrow_center.y + 50 * sin(arrow_angle));
        Point2f arrow_tail(arrow_center.x - 50 * cos(arrow_angle),
            arrow_center.y - 50 * sin(arrow_angle));

        // 绘制箭头
        arrowedLine(image, arrow_tail, arrow_head, Scalar(0, 0, 255), 3);

        // 将箭头中心向前移动10个像素
        arrow_center.x += 10 * cos(arrow_angle);
        arrow_center.y += 10 * sin(arrow_angle);

        // 如果箭头越过边界，则将其移回中央
        if (arrow_center.x < 0 || arrow_center.y < 0 ||
            arrow_center.x > image.rows || arrow_center.y > image.cols) {
            arrow_center.x = image.cols / 2;
            arrow_center.y = image.rows / 2;
        }

        // 如果应该闪烁，将箭头颜色改为绿色，否则为红色


        // 显示图像
        imshow("Arrow", image);

        // 等待一会儿
        waitKey(100);
        //if ((int)(arrow_angle / CV_PI * 5) % 2 == 0) {
            arrowedLine(image, arrow_tail, arrow_head, Scalar(0, 255, 0), 3);
        //}
        imshow("Arrow", image);
    }

    return 0;
}





//
//#include <iostream>
//#include <opencv2/opencv.hpp>  // 包含OpenCV库
//#include "common.h"
//#include "other.h"
//
//#include <fstream>
//
//using namespace cv;
//using namespace std;
//
//bool LoadMap(const char* file_name, SlamMap_& slammap, vector<int>& boundarypoint);
//
//bool ReadRegionFile(std::vector<R_P>& rough_region_list, std::vector<Segment_line>& line_list, cv::Mat& canvas);
//
//
//int main()
//{
//    
//    Mat image(300, 300, CV_8UC3, Scalar(255, 255, 255));// 创建一个黑色背景的图像，大小为400*400
//
//	//读取地图
//	SlamMap_ slammap;
//	vector<int> boundarypoint;
//	//vector<int> boundarypoint;
//	vector<pair<int,int>> boundarypoint2d;
//
//
//	LoadMap("F://map/map.txt", slammap, boundarypoint);
//
//	//cv::Mat canvas(300, 300, CV_8UC3, cv::Scalar(255, 255, 255)); // 创建一个300x300像素的画布
//	//cv::waitKey(10000);
//	for (int i = 0; i < boundarypoint.size(); i++)
//	{
//		//vertices.push_back(sf::Vertex(sf::Vector2f(boundarypoint[i]%slammap.width,boundarypoint[i] / slammap.width)));
//		cv::circle(image, cv::Point(boundarypoint[i] % slammap.width, boundarypoint[i] / slammap.width), 2, cv::Scalar(200, 200, 200), -1);
//		boundarypoint2d.push_back({ boundarypoint[i] % slammap.width ,boundarypoint[i] / slammap.width });
//		cv::imshow("Robot", image);
//	}
//	cv::waitKey(10); // 等待10秒
//
//
//    //设置箭头的初始位置和方向
//    Point2f arrow_center(110, 60);  //箭头中心点
//    double arrow_angle = 0.0;        //箭头角度（弧度）
//
//	// 循环处理每帧图像
//	boundarypoint2d.push_back(boundarypoint2d.back());
//	for (int i = 0; i < boundarypoint2d.size()-1; i++)
//	{
//		arrow_center.x = boundarypoint2d[i].first;
//		arrow_center.y = boundarypoint2d[i].second;
//
//		arrow_angle = atan2(boundarypoint2d[i + 1].first - boundarypoint2d[i].first,
//			boundarypoint2d[i + 1].second - boundarypoint2d[i].second);
//		
//
//
//		// 旋转箭头（旋转）
//		//arrow_angle += 0.5;
//		//if (arrow_angle >= 2 * CV_PI) {
//		//	arrow_angle -= 2 * CV_PI;
//		//}
//		//
//
//
//
//		// 计算箭头的头和尾位置(大小)
//		Point2f arrow_head(arrow_center.x + 10 * cos(arrow_angle),
//			arrow_center.y + 10 * sin(arrow_angle));
//		Point2f arrow_tail(arrow_center.x - 10 * cos(arrow_angle),
//			arrow_center.y - 10 * sin(arrow_angle));
//
//		// 绘制箭头
//		arrowedLine(image, arrow_tail, arrow_head, Scalar(0, 0, 255), 2);//后面的表示箭头粗细
//
//		//// 将箭头中心向前移动10个像素（移动距离）
//		//arrow_center.x += 20 * cos(arrow_angle);
//		//arrow_center.y += 20 * sin(arrow_angle);
//
//
//		//// 如果箭头越过边界，则将其移回中央
//		//if (arrow_center.x < 0 || arrow_center.y < 0 ||
//		//	arrow_center.x > image.rows || arrow_center.y > image.cols) {
//		//	arrow_center.x = image.cols / 2;
//		//	arrow_center.y = image.rows / 2;
//		//}
//
//
//
//
//		imshow("Robot", image);
//		waitKey(10);
//
//		// 运动后留下轨迹
//		arrowedLine(image, arrow_tail, arrow_head, Scalar(0, 255, 0), 2);
//		imshow("Robot", image);
//	}
//
//
//
//  //  // 循环处理每帧图像
//  //  while (true) {
//  //      // 旋转箭头（旋转）
//  //      arrow_angle += 0.5;
//  //      if (arrow_angle >= 2 * CV_PI) {
//  //          arrow_angle -= 2 * CV_PI;
//  //      }
//
//  //      // 计算箭头的头和尾位置(大小)
//  //      Point2f arrow_head(arrow_center.x + 5 * cos(arrow_angle),
//  //          arrow_center.y + 5 * sin(arrow_angle));
//  //      Point2f arrow_tail(arrow_center.x - 5 * cos(arrow_angle),
//  //          arrow_center.y - 5 * sin(arrow_angle));
//
//  //      // 绘制箭头
//  //      arrowedLine(image, arrow_tail, arrow_head, Scalar(0, 0, 255), 2);//后面的表示箭头粗细
//
//  //      // 将箭头中心向前移动10个像素（移动距离）
//  //      arrow_center.x += 20 * cos(arrow_angle);
//  //      arrow_center.y += 20 * sin(arrow_angle);
//
//  //      // 如果箭头越过边界，则将其移回中央
//  //      if (arrow_center.x < 0 || arrow_center.y < 0 ||
//  //          arrow_center.x > image.rows || arrow_center.y > image.cols) {
//  //          arrow_center.x = image.cols / 2;
//  //          arrow_center.y = image.rows / 2;
//  //      }
//  //      imshow("Robot", image);
//		//waitKey(1000);
//
//  //      // 运动后留下轨迹
//  //      arrowedLine(image, arrow_tail, arrow_head, Scalar(0, 255, 0), 2);
//  //      imshow("Robot", image);
//  //  }
//
//    return 0;
//}
//
//
//
//bool LoadMap(const char* file_name, SlamMap_ &slammap, vector<int> &boundarypoint)
//{
//	//读取地图数据
//	ifstream readfile(file_name, ios::in | std::ios::binary);
//	if (readfile.is_open())
//	{
//		cout << "文件打开成功" << endl;
//		readfile.read((char*)&slammap.map_x_start_point_pos, sizeof(slammap.map_x_start_point_pos));
//		readfile.read((char*)&slammap.map_y_start_point_pos, sizeof(slammap.map_y_start_point_pos));
//		readfile.read((char*)&slammap.width, sizeof(slammap.width));
//		readfile.read((char*)&slammap.height, sizeof(slammap.height));
//		//readfile.read((char*)&slammap.resolution, sizeof(slammap.resolution));
//		readfile.read((char*)&slammap.map_build_success, sizeof(slammap.map_build_success));
//		readfile.read((char*)&slammap.charger_pose, sizeof(slammap.charger_pose));
//		cout << slammap.height << "   " << slammap.width << endl;
//		cout << "resolution   " << slammap.resolution << endl;
//		slammap.map_value = (uint8_t*)malloc((slammap.height * slammap.width));
//		readfile.read((char*)slammap.map_value, (slammap.height * slammap.width));
//		for (int i = 0; i < slammap.height * slammap.width; i++)
//		{
//			if ((int)slammap.map_value[i] == 1)
//			{
//				boundarypoint.push_back(i);
//			}
//		}
//	}
//	else
//	{
//		cout << "文件打开失败" << endl;
//	}
//	readfile.close();
//	return true;
//}
//
//bool ReadRegionFile(std::vector<R_P>& rough_region_list, std::vector<Segment_line>& line_list, cv::Mat& canvas)
//{
//
//	ifstream in_data("F://map/region.txt", ios::binary | std::ios::in);
//	if (!in_data.is_open()) {
//		printf("pnc open %s failed \n", "region.txt");
//		return false;
//	}
//	//vector<int> boundarypoint;
//	//std::vector<sf::Vertex> vertices;
//	std::vector<pair<int, int>> Circlecenter;
//
//	uint8_t rough_region_cnt = 0;
//	in_data.read((char*)&rough_region_cnt, sizeof(rough_region_cnt));
//	//cout << "粗分区：" ;
//	for (int i = 0; i < rough_region_cnt; ++i)
//	{
//
//		R_P rough_region;
//
//		uint8_t rough_region_id = 0;
//		in_data.read((char*)&rough_region_id, sizeof(rough_region_id));
//		rough_region.id = rough_region_id;
//
//		uint16_t rough_region_center_x = 0;
//		uint16_t rough_region_center_y = 0;
//		in_data.read((char*)&rough_region_center_x, sizeof(rough_region_center_x));
//		in_data.read((char*)&rough_region_center_y, sizeof(rough_region_center_y));
//		rough_region.center.x = rough_region_center_x;
//		rough_region.center.y = rough_region_center_y;
//
//		uint16_t rough_region_boundary_cnt = 0;
//		in_data.read((char*)&rough_region_boundary_cnt, sizeof(rough_region_boundary_cnt));
//
//		uint16_t* rough_region_boundary_x = new uint16_t[rough_region_boundary_cnt];
//		uint16_t* rough_region_boundary_y = new uint16_t[rough_region_boundary_cnt];
//		in_data.read((char*)rough_region_boundary_x, sizeof(uint16_t) * rough_region_boundary_cnt);
//		in_data.read((char*)rough_region_boundary_y, sizeof(uint16_t) * rough_region_boundary_cnt);
//		cout << "粗分区：" << i << "(" << rough_region_boundary_cnt << ")" << "细分有：";
//		for (int k = 0; k < rough_region_boundary_cnt; ++k)
//		{
//			Point_boundary temp;
//			temp.x = rough_region_boundary_x[k];
//			temp.y = rough_region_boundary_y[k];
//			rough_region.coasre_partition.push_back(temp);
//			cv::circle(canvas, cv::Point(temp.x, temp.y), 1, cv::Scalar(0, 0, 105), -1);
//			cv::imshow("Canvas", canvas);
//
//		}
//		cv::waitKey(10); // 等待10秒
//		if (rough_region_boundary_x)
//		{
//			delete[] rough_region_boundary_x;
//			rough_region_boundary_x = nullptr;
//		}
//		if (rough_region_boundary_y)
//		{
//			delete[] rough_region_boundary_y;
//			rough_region_boundary_y = nullptr;
//		}
//
//		uint8_t precise_region_cnt = 0;
//		in_data.read((char*)&precise_region_cnt, sizeof(precise_region_cnt));
//		for (int j = 0; j < precise_region_cnt; ++j)
//		{
//			cout << " " << j;
//			std::vector<Point_boundary> precise_region_boundary;
//			uint16_t precise_region_boundary_cnt = 0;
//			in_data.read((char*)&precise_region_boundary_cnt, sizeof(precise_region_boundary_cnt));
//			uint16_t* precise_region_boundary_x = new uint16_t[precise_region_boundary_cnt];
//			uint16_t* precise_region_boundary_y = new uint16_t[precise_region_boundary_cnt];
//			in_data.read((char*)precise_region_boundary_x, sizeof(uint16_t) * precise_region_boundary_cnt);
//			in_data.read((char*)precise_region_boundary_y, sizeof(uint16_t) * precise_region_boundary_cnt);
//			for (int k = 0; k < precise_region_boundary_cnt; ++k)
//			{
//				Point_boundary temp;
//				temp.x = precise_region_boundary_x[k];
//				temp.y = precise_region_boundary_y[k];
//				precise_region_boundary.push_back(temp);
//				cv::circle(canvas, cv::Point(temp.x, temp.y), 6, cv::Scalar(0, 0, 255), -1);
//				cv::imshow("Canvas", canvas);
//
//			}
//			cv::waitKey(2000); // 等待10秒
//
//
//			cout << "(" << precise_region_boundary_cnt << ")";
//			rough_region.p_partition.push_back(precise_region_boundary);
//			if (precise_region_boundary_x)
//			{
//				delete[] precise_region_boundary_x;
//				precise_region_boundary_x = nullptr;
//			}
//			if (precise_region_boundary_y)
//			{
//				delete[] precise_region_boundary_y;
//				precise_region_boundary_y = nullptr;
//			}
//		}
//		rough_region_list.push_back(rough_region);
//		cout << endl;
//	}
//
//
//
//	uint8_t line_cnt = 0;
//	in_data.read((char*)&line_cnt, sizeof(line_cnt));
//	for (int i = 0; i < line_cnt; ++i)
//	{
//		Segment_line temp;
//		uint16_t line_start_x = 0;
//		uint16_t line_start_y = 0;
//		in_data.read((char*)&line_start_x, sizeof(line_start_x));
//		in_data.read((char*)&line_start_y, sizeof(line_start_y));
//		temp.start.x = line_start_x;
//		temp.start.y = line_start_y;
//
//		uint16_t line_end_x = 0;
//		uint16_t line_end_y = 0;
//		in_data.read((char*)&line_end_x, sizeof(line_end_x));
//		in_data.read((char*)&line_end_y, sizeof(line_end_y));
//		temp.end.x = line_end_x;
//		temp.end.y = line_end_y;
//		line_list.push_back(temp);
//	}
//
//	in_data.close();
//
//
//	return true;
//}
//
//
//
//
//
//
//
//
//
////#include <opencv2/opencv.hpp> // 包含OpenCV头文件
////#include <vector>
////#include <iostream>
////
////using namespace std;
////
////int main()
////{
////    vector<pair<int, int>>v = { {0,1},{2,3} };
////    for (auto& i : v) {
////        cout << i.first << "," << i.second << endl;
////    }
////
////    cv::Mat canvas(300, 300, CV_8UC3, cv::Scalar(255, 255, 255)); // 创建一个300x300像素的画布
////
////    // 显示第一个圆
////    cv::circle(canvas, cv::Point(150, 150), 50, cv::Scalar(0, 0, 255), -1);
////    cv::imshow("Canvas", canvas);
////    cv::waitKey(3000); // 等待10秒
//// 
////    cv::Mat canvas1;
////    resize(canvas, canvas1, cv::Size(300 * 2, 300 * 2));
////
////    // 显示第二个圆
////    cv::circle(canvas1, cv::Point(150, 150), 100, cv::Scalar(0, 255, 0), -1);
////    cv::imshow("Canvas", canvas1);
////    cv::waitKey(0); // 等待按下任意键退出
////
////    return 0;
////}
////
////
//////// Car_Control.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
////////
//////
//////#include <iostream>
//////
//////int main()
//////{
//////    std::cout << "Hello World!\n";
//////}
//////
//////// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
//////// 调试程序: F5 或调试 >“开始调试”菜单
//////
//////// 入门使用技巧: 
////////   1. 使用解决方案资源管理器窗口添加/管理文件
////////   2. 使用团队资源管理器窗口连接到源代码管理
////////   3. 使用输出窗口查看生成输出和其他消息
////////   4. 使用错误列表窗口查看错误
////////   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
////////   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件
